home *** CD-ROM | disk | FTP | other *** search
/ Pascal Super Library / Pascal Super Library (CW International)(1997).bin / DELPHI32 / SEARCH / RUBICON / RBUPDATE.PAS < prev    next >
Pascal/Delphi Source File  |  1996-10-21  |  14KB  |  497 lines
  1. {*********************************************************}
  2. {*             RBUPDATE.PAS 1.20             *}
  3. {*      Copyright (c) Tamarack Associates 1996.     *}
  4. {*           All rights reserved.          *}
  5. {*********************************************************}
  6.  
  7. {$B-}     {* Boolean evaluation *}
  8. {$G+}     {* Generate 286 code  *}
  9. {$X+}     {* eXtended syntax    *}
  10.  
  11. UNIT rbUpdate;
  12.  
  13. INTERFACE
  14.  
  15. USES
  16.   {$IFDEF WIN32}
  17.   Windows,
  18.   {$ELSE}
  19.   WinTypes, WinProcs,
  20.   {$ENDIF}
  21.   Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  22.   Grids, DBGrids, StdCtrls, taRubicn, DB, DBTables, ExtCtrls, Menus;
  23.  
  24. TYPE
  25.   TStatPanel  = (spCache,spMemory,spWords,spLRU);
  26.   TStatPanels = SET OF TStatPanel;
  27.  
  28.   TUpdateStatsForm = CLASS(TForm)
  29.     ResetBtn: TButton;
  30.     CachePanel: TPanel;
  31.     CacheLabel: TLabel;
  32.     DiskLabel: TLabel;
  33.     ReadsLabel: TLabel;
  34.     CacheReads: TLabel;
  35.     DiskReads: TLabel;
  36.     DiskInserts: TLabel;
  37.     CacheInserts: TLabel;
  38.     InsertsLabel: TLabel;
  39.     EditsLabel: TLabel;
  40.     DiskEdits: TLabel;
  41.     DeleteLabel: TLabel;
  42.     DiskDeletes: TLabel;
  43.     MemoryPanel: TPanel;
  44.     MemCurrentLabel: TLabel;
  45.     MaximumLabel: TLabel;
  46.     MemoryLabel: TLabel;
  47.     MemUsage: TLabel;
  48.     MaxMemUsed: TLabel;
  49.     WordsPanel: TPanel;
  50.     WordsLabel: TLabel;
  51.     UnCompressed: TLabel;
  52.     Compressed: TLabel;
  53.     CompressLabel: TLabel;
  54.     CacheEdits: TLabel;
  55.     UnCompressedLabel: TLabel;
  56.     BlobLabel: TLabel;
  57.     BlobReads: TLabel;
  58.     BlobWrites: TLabel;
  59.     MemLimitLabel: TLabel;
  60.     MemoryLimit: TLabel;
  61.     UnWrittenLabel: TLabel;
  62.     FlushBtn: TButton;
  63.     LRUPanel: TPanel;
  64.     LRU: TLabel;
  65.     CompressLRU: TLabel;
  66.     FLushLRU: TLabel;
  67.     LRULabel: TLabel;
  68.     LRUCurrentLabel: TLabel;
  69.     LRUCompressLabel: TLabel;
  70.     LRUFlushLabel: TLabel;
  71.     PopupMenu1: TPopupMenu;
  72.     CacheMenuItem: TMenuItem;
  73.     MemoryMenuItem: TMenuItem;
  74.     WordsMenuItem: TMenuItem;
  75.     LRUMenuItem: TMenuItem;
  76.     ExpandMenuItem: TMenuItem;
  77.     UnWritten: TLabel;
  78.     PROCEDURE ResetBtnClick(Sender: TObject);
  79.     PROCEDURE ExpandBtnClick(Sender: TObject);
  80.     PROCEDURE HidePanelDblClick(Sender: TObject);
  81.     PROCEDURE FormDblClick(Sender: TObject);
  82.     PROCEDURE MenuItemClick(Sender: TObject);
  83.     PROCEDURE FlushBtnClick(Sender: TObject);
  84.     PROCEDURE FormShow(Sender: TObject);
  85.   PRIVATE
  86.     FExpanded         : BOOLEAN;
  87.     FLastUpdate      : LONGINT;
  88.     FPanels         : TStatPanels;
  89.     FRefreshInterval : LONGINT;
  90.     FUpdater         : TUpdateDictionary;
  91.     PROCEDURE    SetExpanded(Value : BOOLEAN);
  92.     PROCEDURE    SetPanels(Value : TStatPanels);
  93.   PROTECTED
  94.    PROCEDURE    Notification(AComponent : TComponent ;
  95.                  Operation : TOperation); OVERRIDE;
  96.   PUBLIC
  97.     { Public declarations }
  98.     CONSTRUCTOR Create(AOwner : TComponent); OVERRIDE;
  99.     PROCEDURE    UpdateStats;
  100.   PUBLISHED
  101.     PROPERTY    Expanded : BOOLEAN READ FExpanded WRITE SetExpanded DEFAULT FALSE;
  102.     PROPERTY    Panels : TStatPanels READ FPanels WRITE SetPanels DEFAULT [spCache,spMemory];
  103.     PROPERTY    RefreshInterval : LONGINT READ FRefreshInterval WRITE FRefreshInterval DEFAULT 500;
  104.     PROPERTY    Updater : TUpdateDictionary READ FUpdater WRITE FUpdater;
  105.   END;
  106.  
  107.   TUpdateStats = CLASS(TComponent)
  108.   PRIVATE
  109.    FExpanded        : BOOLEAN;
  110.    FForm        : TUpdateStatsForm;
  111.    FPanels        : TStatPanels;
  112.    FRefreshInterval : LONGINT;
  113.    FUpdater        : TUpdateDictionary;
  114.    PROCEDURE   SetExpanded(Value : BOOLEAN);
  115.    PROCEDURE   SetPanels(Value : TStatPanels);
  116.    PROCEDURE   SetUpdater(Value : TUpdateDictionary);
  117.    PROCEDURE   Resync;
  118.   PROTECTED
  119.    PROCEDURE   Notification(AComponent : TComponent ;
  120.                 Operation : TOperation); OVERRIDE;
  121.   PUBLIC
  122.    CONSTRUCTOR Create(AOwner : TComponent); OVERRIDE;
  123.    PROCEDURE   UpdateStats;
  124.    PROPERTY    Form : TUpdateStatsForm READ FForm;
  125.   PUBLISHED
  126.    PROPERTY    Expanded : BOOLEAN READ FExpanded WRITE SetExpanded DEFAULT FALSE;
  127.    PROPERTY    Panels : TStatPanels READ FPanels WRITE SetPanels DEFAULT [spCache,spMemory];
  128.    PROPERTY    RefreshInterval : LONGINT READ FRefreshInterval WRITE FRefreshInterval DEFAULT 500;
  129.    PROPERTY    Updater : TUpdateDictionary READ FUpdater WRITE SetUpdater;
  130.   END;
  131.  
  132.   TUpdateTable = CLASS(TUpdateTablePrim)
  133.   PRIVATE
  134.    FUpdateStats : TUpdateStats;
  135.    PROCEDURE   SetUpdater(Value : TUpdateDictionary);
  136.   PROTECTED
  137.    PROCEDURE   DoAfterDelete;  OVERRIDE;
  138.    PROCEDURE   DoAfterPost;    OVERRIDE;
  139.    PROCEDURE   DoBeforeDelete; OVERRIDE;
  140.    PROCEDURE   DoBeforeEdit;   OVERRIDE;
  141.    PROCEDURE   DoBeforeInsert; OVERRIDE;
  142.    PROCEDURE   Notification(AComponent: TComponent; Operation: TOperation); OVERRIDE;
  143.    PROPERTY    Updater : TUpdateDictionary READ FUpdater WRITE SetUpdater;
  144.   PUBLIC
  145.    CONSTRUCTOR Create(AOwner : TComponent); OVERRIDE;
  146.   PUBLISHED
  147.    PROPERTY UpdateStats : TUpdateStats READ FUpdateStats WRITE FUpdateStats;
  148.   END;
  149.  
  150. VAR
  151.   UpdateStatsForm: TUpdateStatsForm;
  152.  
  153. IMPLEMENTATION
  154.  
  155. {$R *.DFM}
  156.  
  157. PROCEDURE TUpdateStatsForm.SetPanels(Value : TStatPanels);
  158. VAR      NewTop : INTEGER;
  159.  
  160.  PROCEDURE SetNewTop(P : TPanel);
  161.  BEGIN
  162.   IF P.Visible THEN
  163.    BEGIN
  164.     P.Top := NewTop;
  165.     INC(NewTop,P.Height + 7)
  166.    END
  167.  END;
  168.  
  169. BEGIN
  170.  IF Value <> FPanels THEN
  171.   BEGIN
  172.    CachePanel.Visible  := spCache IN Value;
  173.    MemoryPanel.Visible := spMemory IN Value;
  174.    WordsPanel.Visible  := spWords IN Value;
  175.    LRUPanel.Visible    := spLRU IN Value;
  176.    NewTop := CachePanel.Top;
  177.    SetNewTop(CachePanel);
  178.    SetNewTop(MemoryPanel);
  179.    SetNewTop(WordsPanel);
  180.    SetNewTop(LRUPanel);
  181.    ResetBtn.Top   := NewTop;
  182.    FlushBtn.Top   := NewTop;
  183.    ClientHeight   := NewTop + ResetBtn.Height + 7;
  184.    FPanels      := Value;
  185.    CacheMenuItem.Checked  := CachePanel.Visible;
  186.    MemoryMenuItem.Checked := MemoryPanel.Visible;
  187.    WordsMenuItem.Checked  := WordsPanel.Visible;
  188.    LRUMenuItem.Checked      := LRUPanel.Visible;
  189.    UpdateStats;
  190.   END
  191. END;
  192.  
  193. PROCEDURE TUpdateStatsForm.SetExpanded(Value : BOOLEAN);
  194.  
  195.  PROCEDURE SetWidths(PWidth, FWidth : INTEGER ; IsVisible : BOOLEAN);
  196.  BEGIN
  197.   CachePanel.Width  := PWidth;
  198.   MemoryPanel.Width := PWidth;
  199.   WordsPanel.Width  := PWidth;
  200.   LRUPanel.Width    := PWidth;
  201.   Width := FWidth;
  202.   BlobLabel.Visible     := IsVisible;
  203.   BlobReads.Visible     := IsVisible;
  204.   BlobWrites.Visible     := IsVisible;
  205.   MemLimitLabel.Visible  := IsVisible;
  206.   MemoryLimit.Visible     := IsVisible;
  207.   UnWrittenLabel.Visible := IsVisible;
  208.   UnWritten.Visible     := IsVisible;
  209. { CacheCount.Visible     := IsVisible; }
  210.   LRUFlushLabel.Visible  := IsVisible;
  211.   FlushLRU.Visible     := IsVisible;
  212.  END;
  213.  
  214. BEGIN
  215.  IF Value <> FExpanded THEN
  216.   BEGIN
  217.    FExpanded := Value;
  218.    ExpandMenuItem.Checked := Value;
  219.    IF Value THEN
  220.     BEGIN
  221.      SetWidths(193 + 64,223 + 64,TRUE);
  222.      UpdateStats
  223.     END
  224.    ELSE SetWidths(193,223,FALSE)
  225.   END
  226. END;
  227.  
  228. PROCEDURE TUpdateStatsForm.UpdateStats;
  229. VAR      CS   : TCacheStats;
  230.       Tics : LONGINT;
  231. BEGIN
  232.  IF (FUpdater = NIL) OR (WindowState = wsMinimized) THEN EXIT;
  233.  Tics := GetTickCount;
  234.  IF Tics - FLastUpdate <= FRefreshInterval THEN EXIT;
  235.  FLastUpdate := Tics;
  236.  IF CachePanel.Visible THEN
  237.   BEGIN
  238.    CacheReads.Caption  := IntToStr(FUpdater.CacheReads);
  239.    DiskReads.Caption   := IntToStr(FUpdater.DiskReads);
  240.    CacheEdits.Caption  := IntToStr(FUpdater.CacheEdits);
  241.    CacheInserts.Caption:= IntToStr(FUpdater.CacheInserts);
  242.    DiskInserts.Caption := IntToStr(FUpdater.DiskInserts);
  243.    DiskEdits.Caption   := IntToStr(FUpdater.DiskEdits);
  244.    DiskDeletes.Caption := IntToStr(FUpdater.DiskDeletes);
  245.    BlobWrites.Caption  := IntToStr(FUpdater.BlobBytesWritten);
  246.    BlobReads.Caption   := IntToStr(FUpdater.BlobBytesRead)
  247.   END;
  248.  IF MemoryPanel.Visible THEN
  249.   BEGIN
  250.    MemUsage.Caption    := IntToStr(FUpdater.MemoryUsage DIV 1000);
  251.    MaxMemUsed.Caption  := IntToStr(FUpdater.MaxMemUsed DIV 1000);
  252.    MemoryLimit.Caption := IntToStr(FUpdater.MemoryLimit DIV 1000)
  253.   END;
  254.  IF WordsPanel.Visible THEN
  255.   BEGIN
  256.    FUpdater.GetCacheStats(CS);
  257.    UnCompressed.Caption := IntToStr(CS.UnCompressed);
  258.    Compressed.Caption    := IntToStr(CS.Compressed);
  259.    IF Unwritten.Visible THEN
  260.     UnWritten.Caption    := IntToStr(CS.Unwritten);
  261. {  Unassigned.Caption    := IntToStr(CS.Unassigned); }
  262. {  CacheCount.Caption    := IntToStr(FUpdater.CacheCount) }
  263.   END;
  264.  IF LRUPanel.Visible THEN
  265.   BEGIN
  266.    IF NOT WordsPanel.Visible THEN FUpdater.GetCacheStats(CS);
  267.    LRU.Caption        := IntToStr(CS.LRU);
  268.    CompressLRU.Caption    := IntToStr(CS.CompressLRU);
  269.    FlushLRU.Caption    := IntToStr(CS.FlushLRU)
  270.   END;
  271.  Application.ProcessMessages;
  272. END;
  273.  
  274. PROCEDURE TUpdateStatsForm.ResetBtnClick(Sender: TObject);
  275. BEGIN
  276.  IF FUpdater <> NIL THEN
  277.   BEGIN
  278.    FUpdater.ResetStats;
  279.    UpdateStats
  280.   END
  281. END;
  282.  
  283. PROCEDURE TUpdateStatsForm.ExpandBtnClick(Sender: TObject);
  284. BEGIN
  285.  Expanded := NOT Expanded
  286. END;
  287.  
  288. PROCEDURE TUpdateStatsForm.FormShow(Sender: TObject);
  289. BEGIN
  290.  FLastUpdate := 0;
  291.  UpdateStats
  292. END;
  293.  
  294. PROCEDURE   TUpdateStatsForm.Notification(AComponent : TComponent ;
  295.                       Operation : TOperation);
  296. BEGIN
  297.  IF (Operation = opRemove) AND
  298.     (AComponent = FUpdater) THEN
  299.   FUpdater := NIL;
  300.  IF (Operation = opInsert) AND
  301.     (FUpdater = NIL) AND
  302.     (csDesigning IN ComponentState) AND
  303.     (AComponent IS TUpdateDictionary) THEN
  304.   FUpdater := TUpdateDictionary(AComponent)
  305. END;
  306.  
  307. CONSTRUCTOR TUpdateStatsForm.Create(AOwner : TComponent);
  308. BEGIN
  309.  INHERITED Create(AOwner);
  310.  FExpanded := TRUE;
  311.  Expanded  := FALSE;
  312.  Panels := [spCache,spMemory];
  313.  FRefreshInterval := 500
  314. END;
  315.  
  316. PROCEDURE TUpdateStatsForm.HidePanelDblClick(Sender: TObject);
  317. begin
  318.   Panels := Panels - [TStatPanel((Sender AS TPanel).Tag)]
  319. end;
  320.  
  321. PROCEDURE TUpdateStatsForm.FormDblClick(Sender: TObject);
  322. begin
  323.  Panels := [spCache..spLRU]
  324. end;
  325.  
  326. PROCEDURE TUpdateStatsForm.MenuItemClick(Sender: TObject);
  327. begin
  328.  WITH Sender AS TMenuItem DO
  329.   BEGIN
  330.    Checked := NOT Checked;
  331.    IF Checked THEN Panels := Panels + [TStatPanel(Tag)]
  332.    ELSE Panels := Panels - [TStatPanel(Tag)]
  333.   END
  334. end;
  335.  
  336. PROCEDURE TUpdateStatsForm.FlushBtnClick(Sender: TObject);
  337. begin
  338.  IF FUpdater <> NIL THEN
  339.   BEGIN
  340.    FUpdater.FlushCache;
  341.    UpdateStats
  342.   END
  343. end;
  344.  
  345. {******************************* TUpdateStats *********************************}
  346.  
  347. CONSTRUCTOR TUpdateStats.Create(AOwner : TComponent);
  348. VAR        i : INTEGER;
  349. BEGIN
  350.  INHERITED Create(AOwner);
  351.  FExpanded := FALSE;
  352.  FPanels   := [spCache,spWords];
  353.  FRefreshInterval := 500;
  354.  IF Assigned(AOwner) AND
  355.     (csDesigning IN ComponentState) THEN
  356.   FOR i := 1 TO AOwner.ComponentCount - 1 DO
  357.    IF AOwner.Components[i] IS TUpdateTable THEN
  358.     WITH TUpdateTable(AOwner.Components[i]) DO
  359.      IF NOT Assigned(FUpdateStats) THEN
  360.       BEGIN
  361.        UpdateStats := Self;
  362.        IF Assigned(FUpdater) THEN Self.Updater := FUpdater;
  363.        BREAK
  364.       END
  365. END;
  366.  
  367. PROCEDURE   TUpdateStats.SetExpanded(Value : BOOLEAN);
  368. BEGIN
  369.  FExpanded := Value;
  370.  Resync
  371. END;
  372.  
  373. PROCEDURE   TUpdateStats.SetPanels(Value : TStatPanels);
  374. BEGIN
  375.  FPanels := Value;
  376.  Resync
  377. END;
  378.  
  379. PROCEDURE   TUpdateStats.SetUpdater(Value : TUpdateDictionary);
  380. BEGIN
  381.  FUpdater := Value;
  382.  Resync
  383. END;
  384.  
  385. PROCEDURE   TUpdateStats.UpdateStats;
  386. VAR        i : INTEGER;
  387. BEGIN
  388.  IF NOT Assigned(FUpdater) AND
  389.     (Owner <> NIL) THEN
  390.   FOR i := 0 TO Owner.ComponentCount - 1 DO
  391.    IF Owner.Components[i] IS TUpdateTable THEN
  392.     WITH TUpdateTable(Owner.Components[i]) DO
  393.      IF Assigned(FUpdater) THEN Self.Updater := FUpdater;
  394.  IF FUpdater = NIL THEN EXIT;
  395.  IF FForm = NIL THEN
  396.   BEGIN
  397.    FForm := TUpdateStatsForm.Create(Self);
  398.    FForm.Show;
  399.    Resync
  400.   END;
  401.  FForm.UpdateStats
  402. END;
  403.  
  404. PROCEDURE   TUpdateStats.Notification(AComponent : TComponent ;
  405.                       Operation : TOperation);
  406. BEGIN
  407.  IF (Operation = opRemove) AND
  408.     (AComponent = FUpdater) THEN
  409.   FUpdater := NIL;
  410.  IF (Operation = opInsert) AND
  411.     (csDesigning IN ComponentState) AND
  412.     (FUpdater = NIL) AND
  413.     (AComponent IS TUpdateDictionary) THEN
  414.   FUpdater := TUpdateDictionary(AComponent)
  415. END;
  416.  
  417. PROCEDURE   TUpdateStats.Resync;
  418. BEGIN
  419.  IF FForm <> NIL THEN
  420.   BEGIN
  421.    FForm.Expanded     := FExpanded;
  422.    FForm.Panels      := FPanels;
  423.    FForm.RefreshInterval := FRefreshInterval;
  424.    FForm.Updater     := FUpdater
  425.   END
  426. END;
  427.  
  428. {******************************* TUpdateTable *********************************}
  429.  
  430. CONSTRUCTOR TUpdateTable.Create(AOwner : TComponent);
  431. BEGIN
  432.  INHERITED Create(AOwner);
  433. END;
  434.  
  435. PROCEDURE   TUpdateTable.SetUpdater(Value : TUpdateDictionary);
  436. BEGIN
  437.  FUpdater := Value;
  438.  IF Assigned(FUpdateStats) THEN FUpdateStats.Updater := Value
  439. END;
  440.  
  441. PROCEDURE   TUpdateTable.DoAfterDelete;
  442. BEGIN
  443.  INHERITED DoAfterDelete;
  444.  IF Assigned(FUpdater) THEN
  445.   BEGIN
  446.    FUpdater.AfterDelete;
  447.    IF Assigned(FUpdateStats) THEN FUpdateStats.UpdateStats
  448.   END
  449. END;
  450.  
  451. PROCEDURE   TUpdateTable.DoAfterPost;
  452. BEGIN
  453.  INHERITED DoAfterPost;
  454.  IF Assigned(FUpdater) THEN
  455.   BEGIN
  456.    FUpdater.AfterPost;
  457.    IF Assigned(FUpdateStats) THEN FUpdateStats.UpdateStats
  458.   END
  459. END;
  460.  
  461. PROCEDURE   TUpdateTable.DoBeforeDelete;
  462. BEGIN
  463.  INHERITED DoBeforeDelete;
  464.  IF Assigned(FUpdater) THEN FUpdater.BeforeDelete
  465. END;
  466.  
  467. PROCEDURE   TUpdateTable.DoBeforeEdit;
  468. BEGIN
  469.  INHERITED DoBeforeEdit;
  470.  IF Assigned(FUpdater) THEN FUpdater.BeforeEdit
  471. END;
  472.  
  473. PROCEDURE   TUpdateTable.DoBeforeInsert;
  474. BEGIN
  475.  INHERITED DoBeforeInsert;
  476.  IF Assigned(FUpdater) THEN FUpdater.BeforeInsert
  477. END;
  478.  
  479. PROCEDURE   TUpdateTable.Notification(AComponent : TComponent ;
  480.                       Operation : TOperation);
  481. BEGIN
  482.  INHERITED Notification(AComponent, Operation);
  483.  IF Operation = opRemove THEN
  484.   IF AComponent = FUpdater THEN Updater := NIL
  485.   ELSE IF AComponent = FUpdateStats THEN FUpdateStats := NIL;
  486.  IF (Operation = opInsert) AND
  487.     NOT Assigned(FUpdateStats) AND
  488.     (csDesigning IN ComponentState) AND
  489.     (AComponent IS TUpdateStats) THEN
  490.   BEGIN
  491.    FUpdateStats := TUpdateStats(AComponent);
  492.    FUpdateStats.FUpdater := FUpdater
  493.   END
  494. END;
  495.  
  496. END.
  497.